2021 Projects

The LLVM JIT API has changed many times over the years. However, the official tutorials have failed to keep up. This project aims to update the official “Building a JIT” tutorials to use the latest version of the OrcJIT API and add new content that might be relevant to new LLLVM users interested in writing their own JIT compilers.

The current implementation of series expansions in SymPy is developed to a large extent, but not complete. There are a few limit failures that need to be addressed, for which the series module is the backbone. This project aims to fix the computation of leading term methods and make them more robust, which will fix many outstanding issues. This project will also add series and asymptotic expansions support to all special functions, and fix some long standing issues with AccumulationBounds and Order terms.

Linux provides two message queue implementations, System V message queues, and POSIX message queues, none of which are currently implemented in gVisor. This project aims to extend gVisor by implementing a minimal version of System V message queues

The project focuses on working in Message view events and Authentication areas. They are Adding configurability for stream typing indicators, Adding read indicators, Adding general OAuth2, re-Authentication and a few others.

Create a web application that integrates with an existing buildbot infrastructure to fully automatically track the performance of many aspects of Halide over time, including but not limited to compile times, code size, memory footprint (RSS and stack usage), and execution speed for both the compiler proper and the optimized pipelines. When evaluating a pull request, a clear visualization can ensure you notice whether there is any metric changed at a glance.

This project aims to implement the CoAP endpoint library for the drogue-cloud project. The endpoint would have the ability to facilitate the publishing of data to an HTTP endpoint (device-to-cloud) and send commands to a device from an HTTP endpoint (cloud-to-device). The project would involve implementing the above cloud side features and test them end to end. This project does not focus on implementing a CoAP client.

Buildpacks are pluggable tools that can be used to transform the source code to OCI compliant images (Docker images) that can run on any cloud. It is a Cloud Native Computing Foundation incubating project that provides a higher level of abstraction compared to Dockerfiles, decoupling the entire operational overhead and automating the process of rendering the applications production-ready. Currently, we don’t have the mechanism to inform the Buildpack Registry Index and Buildpack Registry Namespace repositories if they are updated with the latest Github Actions version or not. Through this project, we aim to accomplish automatically Automating Pull Request to Staging Index - whenever a new version of the github-action repo is released by automating staging tests of new action versions.

ABioTrans Plus is a web server for transcriptome data analysis and visualization. It supports the analysis of microarray and RNASeq data and performs ten different bio-statistical analyses that cover the common analytics for gene expression data. Furthermore, it gives the users access to several bioinformatics tools to perform 12 different bioinformatics analyses on gene/protein datasets. This project aims to develop ABioTrans Plus v3.0 which will support a wider range of high throughput omics data, namely MS-based proteomics and metabolomics data. Furthermore, developing a detailed report with the performed analysis with figures and data ready to be included in the publications. Machine learning is a method of data analysis that automates analytical model building. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention. Machine learning has been used broadly in biological studies for prediction and discovery.

This Project involves making the ODK-X Services Application meet the current UI/UX standards by redesigning the Basic Application Architecture and improving the User Experience of various features provided by the Application, with major emphasis on simplifying the Authentication Workflow.

A dart version of casbin to support access models like ACL, RBAC, ABAC and others.

Allow building Gentoo stages and boot media for other architectures in a robust manner, with increased security and reliability.

Data structures that complex networks (graphs) can model are present almost everywhere. Therefore, it is important to have a software that can visualize and provide insights into such structures. Unfortunately, the vast majority of network visualization and manipulation softwares currently available has several limitations. For example, Gephi (Java) does not scale well when the number of nodes increases and cannot deal with 3d layout algorithms natively. Because of those limitations in the currently available network visualization softwares, we propose to develop a client/server network visualization for FURY. Our proposed system is inspired by the following work: “Harnessing WebGL and WebSockets for a Web-Based Collaborative Graph Exploration Tool”.

This project aims to add a right sidebar to the minimal Hydrogen matrix client that shows :

• Room Information
• Memberlist
• Member Information
• UI to easily share room

Link to Matrix gsoc page

The main focus will be on frontend-related issues particularly, compose features, message area, user interface. Besides that, I’ll work on fixing the issues labeled as bugs. I’m also interested in making the CSS more organized.

The plan is to make the user experience more user-friendly and bug-free. Here is the current list of issues and features that I plan to complete in this project.

• Easy drag and drop of files so that users can instantly share files.
• Easily quote and reply "some selected small part of a message".
• Making the compose box a full-fledged editor with tools for easily writing messages using markdown.
• Making the experience of message failures easy to handle.
• Adding some more features and fixing various old-time bugs.

It is highly unpredictable to guess what issues might come up later. So, the main outline will be to solve any new issue that might get opened later which is related to the frontend, compose box, message area with the ultimate goal of making Zulip much better than before.

Build System

FOSSology’s build system is based on multilevel makefiles that work together to provide a build infrastructure for the project. Although make is a robust build system but it is too outdated and slow compared to modern build systems. Although build configurations are not supposed to be updated as often as source files, there are few noticeable problems with make. This project will migrate the build system to more user freindly and popular CMake.

Workflow (Continuous Integration)

Fossology has been using free Travis CI for all its continuous builds, tests and deployment purposes throughout the organization. GitHub Actions provides better integration, faster build times and is versatile in many other ways. This projects aims at improving the overall CI/CD for the project as well as upgrade the targets and virtual platforms to the latest compatible versions.

While libraries with robust time-series forecasting capability exist in languages like R and Python, one with similar ease-of-use and functionality does not exist in Julia. The goal of this project is to develop and extend Pythia, a Julia library for time-series forecasting. Specifically, Pythia will include common forecasting algorithms (e.g., ETS, Croston's Method, etc.), evaluation metrics, and plotting capabilities. Additionally, Pythia will be compatible with the MLJ ecosystem.

Inspired by forecast, fable, statsmodels, sktime, Pythia will compile a variety of important functions for time series forecasting into one unified interface.

The goal of this project is to implement the MuZero algorithm in Julia, with the following expected benefits:

• attract people from the model-based RL community to Julia
• showcase Julia in an ambitious project that leverages its greatest strengths, and which could not be achieved using another language (with the same level of performances vs flexibility and simplicity)
• make another step towards a generic and flexible RL framework by implementing MuZero on top of AlphaZero.jl, reusing as much code as possible and creating new abstractions if necessary

The City of Boston’s Parks Department maintains a comprehensive data set on trees in Boston. However, it’s a manual and laborious process to get the data (such as conducting site visits for tree counts) on a regular basis. We would like to explore the use of satellite and aerial imagery to get a regularly updated census of trees across the city. We would also like to look at the feasibility of determining tree health and the variety of tree species across the city.

The ideal outcome would be 1) the creation of a new, accurate machine learning model focused on urban tree canopies, 2) the creation of a simple web interface for the Parks Department to upload new aerial imagery for analysis, and 3) the ability to the Parks Department to generate a list of statistics on tree counts to ensure that it continues to plants trees in an equitable manner across the city.

Coccinelle is a C-program matching and transformation tool developed for C programmers to write intuitive code manipulation rules. This tool was initially released for Linux developers who send patches on mailing lists, but it can also be applied to other projects. To describe matching and transformation rules in the source code with a patch-like appearance, Coccinelle employs a domain specific language called the Semantic Patch Language (SmPL), and attempts to manipulate the given C code based on the given SmPL rule. Although SmPL can provide many useful matching and transformation features, there are limits to the C matching patterns that the SmPL grammar can express due to the complexity of the C grammar. This is particularly the case for function headers, that involve complex types, annotations, etc that have been somewhat less tested by the users of Coccinelle. This project will study the current status and limitations of the handleability of function headers by designing and running a script that checks whether each function header in a given project can be parsed correctly and applying it to the latest Linux kernel. Based on the results, any detected problems will be fixed.

Currently CVE Binary Tool’s binary scanning is slow and a software manifest of known packages can be used for quick scanning for CVEs as an early warning system. Here a database is built primarily of top packages from PyPI and the core packages of popular Linux distros like Ubuntu, Fedora, CentOS etc. and a parser that reads the packages from the list and maps them with the database. The checkers for these packages are created alongside.

Also to improve user experience the creation of a backported fix checking utility can be made. It checks the packages with CVE in the scan and a database with the data including backported fix and provides an output if the CVE is fixed.

Quark-Engine is a rule-based android malware detection tool, However, as a contributor of both Quark and its side projects (quark-rule-generate, ruleviewer), we know that Quark currently faces a problem of insufficient number of detection rules. Although Quark-Engine has a side project for automatically generating rules, the performance of generating detection rules is still low, and the multi-process technique used in this project still has problems. Thus, my first object of this proposal is to develop and implement a new strategy for the rule generation technique to improve the efficiency of rule generation and solve the multi-process issues.

Furthermore, the Quark team is now executing a strategy called “Quark Everywhere” which is to expand the influence of Quark among security open source projects. Thus, my second object of this proposal is to help Quark-Engine integrate with other security open-source projects and improve user experiences of Quark-related functionalities to the integrated projects (APKLab, Jadx).

The proposal for GSoC - Zulip aims to improve the overall experience of the Zulip web app by means of implementing full stack features such as send later feature, remind about message feature, clear status text after time feature, deny guest users access to other users, etc. I would like to see Zulip able to cater the needs of its growing user base by implementing features essential for a smooth and high-performance team chat system.

Improve the TX capabilities of SatNOGS using Gnu Radio and C++

Eye tracking has many applications from driver safety to improved accessibility for people with disabilities. There exist expensive and bulky hardware solutions for eye tracking but this project aims to bring robust and accurate eye tracking to everyone. Recent research and the pervasiveness of handheld devices with powerful cameras have now made it easy to have high quality eye tracking right in our pockets!

The aim of this project is to allow researchers and developers all over the world to use our open-sourced eye tracker (with additional features) in new and varied use cases. From simple systems where the phone can be mounted on a stand in a vehicle to track multiple parameters of the driver – drowsiness, gaze, attentiveness to more complex applications like emotion analysis and even lie detection, the sky's the limit.

Boost.Real aims at providing a data-type that can represent all types of computable real numbers and provides the flexibility of performing arbitrary precision arithmetic, the user can always decide and control the amount of precision to be used for a calculation thus controlling the computational power used by the machine. I propose to benchmark the library and compare it against other similar libraries. There is a scope of optimization for Trigonometric functions and performance can be improved by a significant amount. I also plan for several other small optimizations

The primary aim of this project is to enhance Zulip’s Rest API Documentation and to fill the gaps currently present in the documentation. Zulip has a nice framework for writing API Documentation based on the OpenAPI standard with built-in automated tests, but there is a lot of scope in improving the quality of the documentation and how it is presented to the user. Some tasks include generating API pages directly from OpenAPI data, improving the organisation and UI of /register and /events endpoint, adding support for auto-generated API bindings, documenting currently undocumented /api endpoints and fixing the currently open issues related to API Docs area, as well as doing minor API refactoring with appropriate documentation updates.

TARDIS displays logs during the simulation which consists of values of different mathematical variables and the state of the simulation. This is done so that the user can keep track of the convergence of the simulation. However, the user experience can be enhanced by displaying more relevant log messages and displaying the convergence in plots in real-time. This project aims to provide a dedicated logging framework and plots to display the convergence of the simulation in real-time. Apart from that, this project also aims to complete the Monte Carlo Visualisation Project that was put on hold and to add a Dash based dashboard containing all convergence plots for a better simulation tracking experience.

Synthesis is at the heart of organic chemistry. It is the process of constructing a molecule through a series of reactions. Efficient molecular synthesis is significant, especially in areas like medicinal chemistry. However, it can be challenging to plan a synthesis for a complex molecule.

Retrosynthesis is an iterative process of breaking down a target molecule into a series of simpler molecules which are readily available. It provides a systematic way to plan a chemical synthesis. But, as the space of possible chemical reactions is vast, it is hard for chemists to make the right disconnections while optimizing for multiple factors such as the cost of precursors and efficiency of the reaction.

At its heart, the challenge of making a single retrosynthesis prediction can be recast as a Machine Translation task. Consequently, Natural Language Processing techniques can be leveraged to tackle this using Deep Learning.

This project is focused on extending the DeepChem Library to support Retrosynthesis models, specifically to make single step predictions. This will be achieved by implementing a Molecular Transformer model and enhancing support for Reaction datasets.

Tensorflow GAN is a lightweight library that provides a convenient way to train and evaluate GAN models. Through this project different variants of GAN models will be implemented and trained using Tf-GAN, and will be added as examples to the library. Additionally multiple Colab notebooks will also be added, demonstrating the performances of each of the example models in a more appealing manner to the users. This project is aimed at providing users a more convenient way to understand the benefits of using Tf-GANs, encouraging them to make use of the library.

Netlink proposal - motivation, work done

BoB Robotics is an open-source robotics framework in C++, for interfacing hardware with various robot platforms and software tools for running simulation and visualizing data. As a part of the project, I plan to work on the problem of sensor fusion using BoB robotics and Gazebo, to investigate suitable sensor fusion methods for integrating various conventional and bio-inspired sensors. The broad deliverables I plan to achieve during over summer are:

1. Analyze various sensor fusion algorithms for efficiently fusing various conventional and biologically inspired sensors
2. To implement a suitable fusion algorithm for efficient Path Integration and tune the algorithm to inculcate inputs from visual sensors for visual homing

I will continue from last year’s work and improve the clustering algorithm to the in-production code and enhance the previous work. The main problem is to find the correct anchor. For this, I want to propose a celeb detection API of Microsoft azure which is the best for this use case. Currently, the most time-consuming process in the program is going frame by frame and extracting faces. The face-recognition method used in the production code processes each frame individually. I want to upgrade it to a parallelized algorithm to process multiple frames in a batch and increase the processing speed exponentially, which will also help in faster testing of hyperparameters. Batch processing can be much quicker than processing single images at a time. So I think we use batch processing for multi-threading.

This project revolves around designing a reusable framework for mocking the driver side of a VirtQueue operation. It would allow rust-vmm crates and other projects to use it and would provide a cleaner alternative to mocking code already found in vm-virtio.

The framework would at first provide users with more granular control over mocking what the driver will place in the queue and will later support mocking more advanced features such as notification suppression, indirect descriptors and other device specific features.

Currently, the FreeBSD virtual terminal driver vt(4) does not support inputting CJK characters directly in the virtual terminal, so our project idea is to provide an environment that can run IME (input method editor) in the console.

A common usage scenario is when a user wants to create a user with the user info description in Chinese during the system installation. Since the installation process must proceed in a virtual console, there is no way to open an IME window to input CJK characters.

Another example is hosting a FreeBSD server on a cloud platform or a virtual machine. When one wants to do some simple admin routines on the machine or disconnects from the SSH session, he/she needs to do some configurations and keeps records or takes notes on the server. It's sometimes quite inconvenient for those CJK writing-system users to write texts in their most familiar languages.

And we want to implement similar features of those IME (fcitx, ibus) but in the console.

Enhance interoperability in the current Jenkins architecture by designing a plugin for Jenkins which emits and consumes CloudEvents. CloudEvents is an industry-adopted standard specification for describing event and event data (also referred to as Payload). This project enables Jenkins to produce CloudEvents (as a source) for common Jenkins events like a project build success/failure, which other tools (example Azure Event Grid) can consume. This project also enables Jenkins to be configured as a sink where external tools (example Amazon Kinesis) can send CloudEvents, and Jenkins can consume those events to perform a Jenkins action. Implementing this plugin in a workflow will give Jenkins users the ability to use and extend an event-driven Jenkins workflow to systems which use CloudEvents for defining their events.

Nowadays, Ceph supports Kafka, HTTP and AMQP(ver 0.9.1) endpoints natively from the Ceph Rados Gateway. However, to allow for a large variety of endpoint types to integrate with Ceph, we are encountered with some inconvenience on these various protocols from different service infrastructure. The workaround for the notification brings the burden of adaptor deployment, communication and translation overhead.

AMQP 1.0 is the latest standard for AMQP. It focuses on core features which are necessary for interoperability at Internet scale, and it contains less explicit routing than previous versions. Even though Ceph has supported the AMQP(ver 0.9.1) natively, the gap between these two protocol specifications cannot be ignored. The next level AMQP(ver 1.0) requires a completely different client library. AMQP 1.0 brokers are supported by Apache Qpid/ActiveMQ project and Azure platform, etc.

To address this problem, we should support the AMQP 1.0 natively in the Ceph Rados Gateway. This requires adding the qpid-proton client library to the Rados Gateway code base, and use it to send notifications to AMQP 1.0 compatible brokers.

Chrome OS enables fast and relatively low energy-consuming by utilizing TensorFlow Lite and hardware ML accelerators. The hardware accelerators are great and give good performance in terms of model inference. However, not all operators will be implemented by hardware. And in this case, we need to fallback to a generic solution (CPU backend) to guarantee the model will get run successfully.

The key is to implement a high-performance and stable CPU backend and XNNPACK gives us the opportunity to do so by simply porting its implementation to Chrome OS codebase and align the API and internal calls with our NNAPI.

By porting the most commonly used ops to Chrome OS in XNNPACK, we can run simple models like MobileNet more efficiently than the existing reference operation implementations. with little effort. This would be a big plus to the model and model inference in Chrome OS eco-system.

The Activeloop organization provides data scientists worldwide with a solution to these problems so that they can spend more time training their models and saving resources. Hub is a package that stores petabyte-scale datasets as a single numpy-like array on the cloud, so one can seamlessly access and work with it from any machine. Hub has a simple API that enables its users to obtain a lot of functionality with just a few lines of code. However, as a complete beginner, it is difficult for many to learn the nuances of a new package. Reading the documentation is something that helps, but it is not exactly a fun way of learning something new. It can become tedious and boring. This is exactly why it would be great if Hub had a package that interactively teaches the basics of hub in the CLI itself.

The TensorFlow lite team has already build an Android app using custom Java code which includes BERT question and answering, BERT Text classification and smart reply. The Aim of the project is to build an example android/IOS app for the same but using TensorFlow Lite task library.

A peer to peer messaging app where one could send messages even when there is no internet using ad hoc networks over large area.

In this project, I will be replacing ETL with STL libraries and then will port them to the synfig core. If the perfect replacement for some ETL class is not available in the STL, then I will port it as it is.

Implement a prototype version of proot with Rust language, with the most basic features.

This project aims to make a tool to use results of Betsi and anomaly detectors to generate customisable and rich analysis Reports and make interactive graphs that can be exported in multiple formats.

Thanos Querier component supports basic TLS configuration for internal gRPC communication. This works great for basic use cases but it still requires extra forward proxies to make it work for bigger deployments. It’s also hard to rotate certificates automatically and configure safe mTLS. This project aims to remove those simplifications allowing better TLS story for all Thanos metrics APIs!

Building a platform to support users and compile openwrt packages on the fly by building an executable, code ready docker image , ready to be shipped on K3S cluster.

This project aims at re-implementing the UI for Bench-routes with a user-interface that occupies lesser space and is more compact to look at. Also, it focuses a lot on improving the code design of the front-end to make it more maintainable and efficient. It also ensures that the newer implementation is modular to expand with additional components.

I am applying to work on Ruma's automated checks issue https://github.com/ruma/ruma/issues/221 to build a special-purpose tool to check code style rules and formatting specific to Ruma. I will use rust-analyzer's syntax crate to parse Rust files into a typed AST that is checked against rules. I plan to use this AST to be able to format code inside macros since this is a big part of Ruma. I have started a proof of concept tool ruma-check that I will complete during GSoC.

The Charmil Framework will help in resolving the problems in apache Kafka examples and improve Apache Kafka CLI experience by providing a number of popular Kafka CLI’s as one single HOST CLI with others installable as plugins.

Deliverables

• Provide example applications that can be used to showcase command-line experience.
• Improve base framework (charmil) to Install a plugin CLI in the Host CLI
• Build and deploy registry with different versions of Kafka specific CLIs
• GitHub repo/pages based remote index servers for plugins which will contain docs, metadata, etc.

The user will import charmil in their CLI, which will provide them all the extensions out of the box. The user will be able to install specific plugins with the install command. After installing the extension, users will be able to use the features of that plugin without writing code for that particular feature which that plugin provides.

A GitHub repo will be used as the index server for all plugins. The repository will hold a directory of JSON / YAML files. Each describes a single plugin. This directory is called Plugin Manifest.

This project involves implementation of various anti-spoofing techniques in GNSS-SDR. These techniques include consistency checks to verify and validate received GNSS signals to detect ongoing spoofing attacks.

Simplifying uBlas::matrix and uBlas::vector templates using the new uBlas tensor extension as base implementation.

CGAL’s Axis-Aligned Bounding Box Tree is an acceleration structure which speeds up common tasks such as collision-detection. It is used both directly and throughout other packages in the library, so any performance improvements made to this package will pay dividends elsewhere. The package has already been a major target of performance optimization, but one approach that hasn’t yet been fully explored is the use of SIMD, a type of parallel computation where the processor operates on several data values at a time. The introduction of SIMD optimizations to the AABB tree has the potential to substantially improve performance by better taking advantage of the capabilities of modern computer processors.

I'd like to continue my work on the Director engine from last summer, improving the engine so that it is production ready for some Director 2-4 games, as well as extending it to support Director 5 and higher.

Again, my focus will likely be on Lingo, as well as implementing code to load and play Director 5 movies, and implementing major, missing non-Lingo features such as digital video cast members.

Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework, used in many particle physics data analysis and applications. Currently, we are developing a fast inference system in TMVA that takes the ONNX model as input and produces compilation-ready standalone C++ scripts as output. These scripts will then provide users an easy way to deploy their deep learning models in their physics software and analysis frameworks.

The Data Retriever is a package manager for publicly accessible data. The Data retriever automatically finds, downloads, and pre-processes publicly available datasets and it stores these datasets in a ready-to-analyze state. A number of data providers require the use of an account with an associated Login or API key to access data programmatically. The Data Retriever currently has support for the Kaggle API allowing users to securely use the Data Retriever to install datasets hosted by Kaggle. The goal of this project is to find sources of public Data which require a Login/API key to access the data and integrate them into Data Retriever. Two data sources with Python API (Socrata & CKAN) have been thoroughly researched and are ready to be added. The users will place the appropriate credentials in a file in their home directory. The Data Retriever will automatically identify the required credential files and handle the login/API request to download the dataset.

The procedure for lexical selection training is a bit messy, with various scripts involved that require lots of manual tweaking, and many third party tools to be installed. The goal of this task is to make the training procedure as streamlined and user-friendly as possible

libsecret's, "file database uses an encryption key derived from user's login password. That is not ideal because the entire security relies on the login password and is not able to cope with alternative login methods, such as fingerprint readers. The situation could be improved if the key is protected by hardware, such as TPM2 on consumer notebooks. As TPM2 has a mechanism to securely import/export private keys in a wrapped form (i.e. encrypted), the libsecret implementation merely needs to record the wrapped key as an opaque key handle along with the encrypted database upon writing, and upon reading it can ask TPM2 to decrypt the session key from the key handle. The TPM2 Software Stack provides the necessary functions for that" (Daiki Ueno, n.d.).

References:

Daiki Ueno (n.d.). libsecret: extend file backend to use TPM2 derived encryption keys. Retrieved from https://gitlab.gnome.org/Teams/Engagement/gsoc-2021/-/issues/13

Email is one of the longest standing communication methods since the beginning of the internet and is still widely used and almost every internet user has an email address. One of the core ideas of Matrix is interoperability. Having the option to communicate with everyone without having to worry if the other person is also on the same platform as you are is a major concern while switching to another communication platform.

The entry barrier to the Matrix ecosystem is lower as compared to similar projects due to the support of bridges. IRC, Telegram, Slack, Signal and Gitter bridges, to name a few, have reduced the barrier very much. By bringing email support to the ecosystem, we will be able to push the barrier to almost nil. Imagine the matrix system which will be able to communicate with virtually everyone that has a personal internet address!, i.e, the email ID.

According to an estimation, over 15% or one billion people of the total world population experience significant disabilities. These disabilities can be major or minor but the barriers in social and economic sectors for such people are the same. Even in the field of technology, people with disabilities are usually ignored. They find it tough to use websites and mobile applications. Considering such people a part of society and to make the live chat widget accessible to such people, I will implement a user-accessible mode. This accessible mode will help them to use the exciting features of the live chat widget.

The project aims to introduce Developer Options to oppia-android. There are many instances when a developer needs to make some database related changes. Doing this manually will take up lot of time and effort. Having such an option as this one will prove handy to perform these tasks without much effort and time. It allows the developers to have access to other debug related features such as viewing analytic event logs and forcing the network state of the app which will also prove useful. In short, this project aims to make the lives of developers in the Oppia team a bit easier.

This project would involve developing tools for teaching STEM through p5.js, adding functions to animate shapes, and animating maths symbols. The main focus is to introduce a simple, easy-to-use library to animate repetitive methods. It would provide educators tools to make interactive animated sketches that can support learning in the remote environment. It will take advantage of the p5.js core library - p5.sound.js for sound effects and KaTeX for rendering symbols.

AsyncAPI aims to set an industry standard for messaging APIs by providing a set of tools and features to improve the current state of Event-Driven Architecture in the world of APIs so that it can be referred to as a single source of truth.

This project idea aims to develop a library that focuses on finding and analyzing the relationships between AsyncAPI Documents to get information about Applications described by those files. It would be extendable in a way such that one can provide an additional plugin to the library to obtain output formats other than the default one.

vcf2fhir is a utility to convert VCF files into HL7 FHIR format for genomics-EHR integration. The utility currently converts simple variants (SNVs, MNVs, Indels), along with zygosity and phase relationships, for autosomes, sex chromosomes, and mitochondrial DNA. This project aims to enhance the utility by adding capabilities for the conversion of structural variants (e.g. insertions, deletions, copy number variants).

Neural AutoRegressive Flows are one of the most recent addition to the family of autoregressive flows. By using NAFs, probability density estimation in the domain of scientific exploration can yield amazing results. For example if the background data of a particular device is modelled using NAFs, it can lead to the discovery of new phenomena with very little supervision. Main goals of the project include creating basic reusable building blocks for NAFs, implementing NAFs on the given High Energy Physics data obtained from various experimentation devices, hyperparameter tuning of the NAF model for optimum performance, providing API for training plus inference and finally documenting the API and various components of the system. Final product obtained will not only be easy to use but also easy to extend.

The main goal behind this project is to create a Rocket.Chat app that adds the support of transcribing previously sent audio messages on demand, and new audio messages sent with the transcription selected.

The goal of this coding project is to develop a new R package, named 'cleanTS'. The expected tasks for this project are as follows:

• to understand the concept of existing AutoML tools.
• to review all possible R packages that can be used for time series cleaning (such as outlier detections and imputations) and handling.
• to develop various functions for 'cleanTS' packages (which includes time series analysis, statistics, use of testbenches, reporting summary, visualization, graphical user interface, etc) as guided by the mentors.
• Maintaining and publishing R package (e.g. building, installing, checking, Version control, pull requests, and GitHub)
• to demonstrate the potential of the developed package in several real-world problems.
• to work on novel animated visualization of time series.
• to maintain documentation, tests, Vignettes, and website for the newly developed package.
• to draft a manuscript for the journal submission describing the newly developed package.

Building a cross platform (Android/iOS) chat application which utilises Bluetooth and WiFi-Direct for communication, thus eliminating the need of a central server. The messages will be transferred using an optimal path which can be determined by underlying network protocols and/or GPS positioning. In particular the gossip protocol is used to relay messages through intermediate devices until it reaches its required destination.

Dark matter is one of the biggest questions in current cosmology, and many different theories were created to try to explain it. One of the challenges of studying dark matter is actually finding it, as it is only noticeable due to gravitational interactions. Fortunately, recent results have shown that strong gravitational lensing can be used as a probe for studying dark matter’s substructure. Unsupervised learning algorithms are particularly interesting in this field because they allow for the identification of dark matter substructure without a prior theoretical model assumption. While the performance of these algorithms is very promising, there is still a large gap when compared to supervised learning algorithms. One promising possibility is to use domain adaptation techniques to fine tune the models trained on simulation data with real data. Thus, this project will focus on using domain adaptation to account for the differences in the modelling and available real observation data, while also improving the interface with PyAutoLens, the software used for creating the strong lens simulations.

This project aims to add support of Go-Style Channels to the Chapel language. In Go, a channel is used to synchronize and communicate between different goroutines. A similar library can be added to chapel to support efficient communication between various chapel tasks in a lock-free manner. The channels would enable a user to decompose algorithms into tasks in a more logical way. The work will involve studying the performance against the original Go channels.

The projects aim at extending Coala's support to newer versions of Python. The lack of support for more recent versions has significantly stalled its development. The project will mainly focus on the following:

1. Update coala and bears to support the latest versions of Python.
2. Fix CI/CD pipeline to take the above changes into account.
3. Update docker image to reflect the changes made.

Hence, a Coala with complete Python support will be derived.

This project aims to bring post-training integer quantization to OpenCV’s DNN module and perform inference using 8-bit integer inputs and fixed-point arithmetic. Using a simple quantize() function, any Net object can be quantized, resulting in roughly 1.5x faster inference, 4x reduction in memory consumption and accuracies close to floating-point inference.

360° video is getting popular during the past years and it is predicted to evolve [1]. Compared to virtual and augmented reality, 360° video is much more accessible for viewers. The cameras are getting cheaper, and many video sharing services have an option for 360° video support (YouTube, Vimeo, Facebook) as well as applications (e.g. VLC).

360 video requires special transformations to be viewed: the most popular way to store the data at ERP and CMP projections.

The goal of the project is to implement and optimize ERP and CMP conversion algorithms using GLES. The algorithm will perform 360° video transformations between ERP and CMP. [1] https://images.app.goo.gl/iVyk3qkdxmR7CNGA8

The EOS User Story project aims at providing a user-friendly and interactive platform for users to sign in and request new icons & report bugs for EOS Icons. Also users can track the progress of their issues and vote & comment on issues that are of interest to them. The admins can then review, resolve, close or assign a status to the issues. It serves as an efficient feedback mechanism for organisations, which is necessary for the development of different products. Hence, it is a reusable project for EOS that can be used by any other organisations as well.

In this project I aim to improve EOS User Story by adding some essential features and expanding the test coverage of the project. I will also be working on fixing some existing issues in the application. The features that I will be adding as part of the project include:

1. Request templates
2. Shareable Links for stories
3. Implementing search of stories
4. Shareable search results
5. Integrating OAuth for logging in

For expanding the test coverage I will be using Jest for unit/integration tests and Cypress for end-to-end tests, which can then be deployed to Gitlab CI/CD pipelines and thus will help catch bugs (if any) before a PR is merged.

My most favorite thing about Oppia is its Test-Driven-Environment. All these tests (FE, BE, E2E, Lint) will ensure that no new error or bug will be introduced into the system. Since Oppia is one of the most prominent open-source organizations, it needs rigorous testing and 100% coverage.

Oppia’s frontend codebase can be broadly classified into four main categories.

1.Components

2.DIrectives

3.Services

4.Others

We have a total of 205 components. In which, 163 components have 100% coverage. Partially covered components are 42. And finally, uncovered files are 0.

We have a total of 203 directives. In which, 15 directives have 100% coverage. Partially covered directives are 188. And finally, uncovered files are 1.

We have a total of 333 services. In which, 262 services have 100% coverage. Partially covered services are 71. And finally, uncovered files are 0.

By excluding others category, we should thoroughly test and should achieve 100% coverage in components, directives, and service.

My primary focus for this project is only unit testing. Although I'll be doing angular migration as an optional entity.

Project "Metrics and monitoring" aims to collect more effective metrics which can characterize the current status of pgagroal's pool, connections, clients, servers and internal state. These metrics can be illustrated by one or more Grafana dashboards to show clearly what DBA desires to know about pgagroal itself and PostgreSQL.

RADIS is a fast line-by-line code for synthesizing and fitting infrared absorption and emission spectra such as encountered in laboratory plasmas or exoplanet atmospheres. It uses a line-by-line approach, where each absorption or emission line of a molecule is computed by accounting for the influence of environmental parameters. Even though the current implementation can compute high-temperature spectra of millions of lines in just a few seconds it is quite memory hungry. In order to be able to run computations on high-temperature infrared spectra from databases of tens of millions of lines, it is essential to optimize memory consumption in a way that it is possible for us to run reasonably large data on a regular machine (one that has 8 - 16 GB of RAM). RADIS uses Pandas dataframe for handling all the databases currently. Pandas rule of thumb: have 5 to 10 times as much RAM as the size of the dataset. Which makes it impossible to read say a database of size 5GB on a machine with a RAM of 16GB. The goal of this project would be to reduce the memory usage of the current calculations, which would make it possible to compute spectral databases of up to billions of lines.

This project uses computer vision, satellite imaging (Google Earth), and Analyze Boston to build a lightweight web service API that provides data on the solar energy potential of building roofs throughout the city. Additionally, the application presents to the user their environmental impact and energy savings by switching to solar, and, if they so choose to switch, there are clear call-to-actions to schedule the best Boston solar company for them or to schedule a call with someone who will guide them down the process.

The main objective of this project is to develop a tool for companies or competent authorities to help them visualize certain crop illnesses on the terrain, displaying photographs and locations of plants’ leaves, fruits or trunks on a Liquid Galaxy system. The tool will be developed as an Android app designed for tablets, able to control what is being displayed on the system. The problem that has inspired this project is the fire blight, although other kinds of illnesses can also be displayed.

This project aims to add improvements in the admin panel of openPIP that is used to upload data and files, post announcements and change global settings of installed instances. The project also requires work on the creation of an installation package and installation guide for the new users to follow. Ultimately, the project will prepare openPIP for publication.

My project aims to write autopkgtests for Debian Med packages, fix existing tests that fail and find and fix the errors uncovered by these tests.

PGWEB is the official repository containing the code of the website at https://www.postgresql.org/ The website code is written in Python using the Django framework. However, this infrastructure lacks a testing suite to check for the correct functioning of the website. This project aims to integrate a complete testing suite into the current CI/CD pipeline, including unit tests to test for the view, models, forms, and links, integration tests, functional tests for cross-browser compatibility testing, performance testing, and accessibility testing.

Experiments conducted at the Large Hadron Collider (LHC) are the source of the most important discoveries in new physics. One of the most prominent experiments is the Compact Solenoid (CMS), whose results rely on the reconstruction and detection of particles, jets, and topologies from low-level detector data using an End-to-End Deep Learning (E2E) model. This project intends to investigate the use of multiple Deep Learning architectures to learn the properties of simulated top quark pair events and successfully integrate the best performing architecture into the E2E CMSSW prototype.

In Krita, performing boolean operations on vector shapes leads to a large number of unnecessary nodes. This happens because Qt lacks a proper algorithm to find the intersection point of two Bezier curves. I plan on implementing a numerically stable as well as efficient algorithm to find the intersections of two Bezier curves.

The thought experiments by Valentino Braitenberg that lead to the creation of Braitenberg Vehicles (BVs) help us in very robust modeling of basic emotions emerging from simple neuronal wiring. These emotional responses can be utilized in modeling predator-prey behavior in an ecological setup. Here I propose simulating vervet monkeys' behavioral aspects (Cercopithecus aethiops), especially how they deal with predators in an ecological setting. Vervet monkeys give acoustically different alarm calls to different predators and hence show signs of semantic communication. I will use my already developed agent-based BV simulation platform in developing this simulation, primarily focusing on the communication aspects in vervets.

MediaPipe fills the gap of handling the implementation of models for different systems and allows the developers to focus more on experimentation than on system architectures. WebAssembly has become prominent in recent years as it can port C++ applications onto web browsers, making code more portable and utilizing the efficiencies of C++. In my GSoC internship, I will combine MediaPipe and WebAssembly by building an open-source realtime web video effects app. I will create a complete workflow of wrapping models in MediaPipe to be used in a webapp for running different ML-based video effects live in the browser using WebAssembly. The workflow will include wrapping the model binaries in calculators, create calculator graphs to use the model binaries, set up Bazel for WebAssembly compilation, write Emscripten bindings to access the models, and create a Typescript webapp to demonstrate how to access the WebAssembly binaries in realtime. I have extensive experience in C++ development, along with web development using Javascript. I have also been using MediaPipe for almost a year and am accustomed to the codebase. Hence, I am confident that I will be successful in my internship.

Asterix currently requires a static range hint in the query when performing interval joins. The range hint supplies split points for input data, then data is partitioned and sent to separate nodes based on those split points. A static query hint is nice because it gives the user more control over the split points and data partitioning, but it would be nice to have the option to run a query without having to process the data and its split points in advance. Within the last year, code was added to Asterix that implemented a spatial join with a dynamic range hint. This code can pick split points (or tiles) before the join. For my project, I am going to take that code, learn how it works, and then refactor and write code to make it work with interval data and interval joins.

PoorMan's Rekognition is a unique tool that provides all of amazon Rekognition's Services but with the power of open-source. Its key features include facial analysis, NSFW content detection, OCR module, scene detection both for videos and images. This GSoC proposal builds upon the previous year's work to finally make its services accessible to whomever it may concern.

This year our aim is to fix whatever is broken, improve performance of models, adding new features like image captioning, and finally deploying the project.

This project serves as a modification to the Project “Porting MAVROS for ROS2” and instead aims to provide Ardupilot with native support for ROS2 with basic publish-subscribe features.

The protocol that would be followed to implement the native features would be the XRCE-DDS protocol (DDS for resource-constrained environments). This project would involve the building of an XRCE-DDS client along with necessary IDL files for publishing time-critical vehicle messages across to either an :

• XRCE-Agent (for native DDS models)
• Micro-ROS Agent (for ROS2 nodes) with basic publish-subscribe functionality

This proposal will add griddap functionality to the erddapy package and simplify the API. Support for griddap will enable near real time access to gridded datasets such as climate models and weather forecasts via a simple Python API. This access will benefit oceanographers, search and rescue teams and the maritime industry at large. Additional tasks include enabling high level, simplified queries for easy access and improving the gliderpy package to make swathes of high resolution ocean glider data more readily available.

Firmware as the name suggests is a bridge between User and hardware/features of Axiom Remote. Hence, there is a need for Firmware to follow good UI/UX principles,at the same time should not be heavy on the CPU.

AXIOM-Remote General UI guidelines clearly mentions how things flow in AXIOM-Remote firmware, and the correct structure and plan one should keep in mind. I tend to follow the structure and at the point of dilemma or turmoil would discuss with mentors.

Task mentioned in Firmware Improvement and Extension

• Event handling (button interactions, turning the rotary knob, etc.)
• Page setup
• Add new UI classes
• Text input GUI
• Histogram, scopes and other graphs drawing
• Optimize drawing
• Add transition animations
• Unit tests to verify proper implementation

VLC is the most widely used media-player. It supports wide-range of media formats, both audio and video. For macOS, the UI is outdated, and needs a bit of redesign. This project aims to modernize VLC’s UI and give it a similar feel to the UI on iOS/tvOS.

Open Geometry Viewer is a web-based application to view 3D CAD models on browsers. Users are able to host the model online and comment on others models. I'll fix some bugs, do some enhancements and add some new features to the existing application. My take is to improve the end user's experience with the whole application. Along with that, I'll do some code quality improvements that will help other developers to maintain and drive the code easily in the future.

PyZombies proposed a web application to present all the content of the course, theory, and practical exercises, following the syllabus of Python para Zumbies. This web application intends to be an interactive book, in which the student can be able to run the exercise and get feedback about it.

The aim of the project is to increase the number of active installs in XWiki by providing the end-users with the flexibility to use Cloud Computing or services provided by AWS. There are two types of installations currently present for XWiki - Testing one and Production one. Also, there are two major versions available currently: 12.10.5 - the stable release and 13.2 - the active latest release. Cloud computing has gained significant recognition in the past few years due to the availability of a virtually unlimited number of servers and unlimited power/memory availability within seconds while maintaining a pay-per-use model for billing. As companies and users move to Cloud-based solutions for their server needs, it makes sense that XWiki too should integrate seamlessly with major cloud provider solutions. Currently, Amazon’s AWS has the greatest market share in the Cloud Market, which is greater than the combined market share of Google (GCP) and Microsoft (Azure). Therefore we need to provide AMIs and Cloudformation Templates (in the context of AWS), which end users can consume directly to spin up XWiki within minutes and start testing/working.

This project aims to revamp the Recent topic view with the addition of Multiselect Dropdown List Widget within Zulip frontend and to enhance it by providing better control over recent feed, allowing them to filter by topic unread count and stream unread counts.
This is an essential feature for users within large organizations assisting users to read only specific topics they are interested in and sort by unread topics that they are not caught up with.
The proposal also takes into consideration of reusing specific widgets across various areas (most likey, Settings and Message edit) which can potentially enhance the UI and minimize the user's effort in achieving the desired task.

This project is about visualizing Stellarium in a liquid galaxy setup. I have divided this project into two tasks.

task-1: Setting of view-matrix offset for slaves according to their positions with respect to the master.

task-2: I have identified 16 data parameters which should be shared among cluster in real-time via socket connection.

Each of these tasks is explained in detail in the proposal.

This project proposes to implement a thread pool inside perf, which could be used first to improve the existing parallelization in the synthetic threads and then to parallelize perf-report. Furthermore, the thread pool could be reused in future work in perf to efficiently implement new parallel portions.

This project aims to develop a potential frontend for Niffler. Niffler is currently a command-line tool where the user has to download it in their system and run python commands to retrieve the DICOM images. The main aim of Niffler is to retrieve DICOM images from multiple PACS and store them as png images or metadata files. This can be done currently via the command line. Enhancing this with a frontend and making this a web application would be beneficial and easy to use by a large number of non-technical users and clients.

Financial Organizations using Mifos/Fineract are depending on external agencies or their past experiences for evaluating credit scoring and identification of potential NPAs. Though information from external agencies is required, financial organizations can have an internal scorecard for evaluating loans so that preventive/proactive actions can be done along with external agencies reports. In industry, organizations are using rule based, Statistical and Machine learning methods for credit scoring, predicting potential NPAs, fraud detection and other activities. This project aims to implement a scorecard based on statistical and ML methods for credit scoring and identification of potential NPAs.

Tensorflow GUI will help everyone from beginners to professionals in their day to day work. People who are new to the field of deep learning can use this to build , train and test neural networks without requiring in depth programming knowledge or tensorflow framework. Professionals can use it to create boilerplate code , train and test their models.

During checkpointing and restoring, CRIU locks the network to make sure no TCP packets are accepted by the network stack during the time the process is checkpointed (to avoid the kernel from sending a RST packet). Currently CRIU calls out to iptables-restore to create and delete the corresponding iptables rules. Another approach which avoids calling out to the external binary iptables-restore would be to directly inject eBPF rules. There have been reports from users that iptables-restore fails in some way and eBPF could avoid this external dependency.

This project aims to introduce support for displaying the Copyright Licenses of the third-party Maven dependencies used to build the Oppia-Android application. The implementation involves compiling the list of Maven Dependencies via Bazel query (as the Oppia-android will completely get rid of Gradle soon) and then extract the Copyright Licenses of the Maven Dependencies and then display the License texts in the actual UI of the app.

The TripPy architecture brings transformer models to Goal-oriented Chatbots. While setting new SoTA results on MultiWOZ among others, TripPy also simplifies the previous standard architecture. A better + simpler solution is what we strive for in all fields. This project implements TripPy in DeepPavlov to allow anybody to build fully functional Dialog Bots on top of TripPy leveraging the DeepPavlov ecosystem. Further, the project includes a simple demo in the form of a WeatherBot as well as a more complex chatbot demo built on the new model in DeepPavlov.

Cssselect currently parses CSS3 Selectors and translates them to XPath 1.0 expressions. The project is to expand supported features to CSS4 Selectors.

FOSSology frontend is built using the Symfony framework of PHP. FOSSology needs to be updated with new generation design and color, giving it the power of JavaScript and Bootstrap. It lacks the features and optimizations provided by the other new frameworks/libraries. For this project, I propose to Migrate Fossology UI into the React library, making it faster for development and more adaptive to newer technologies. During the GSoC period, I would rewrite the UI in React from scratch while ensuring a highly scalable, flexible, and easy to use and maintain code architecture. Also, I will be upgrading the existing API and would integrate it with the new frontend code.

I’d like to create a web-based simulator for scheduler behaviour. With web UI, users can...

• create/delete pods, nodes, volumes, and other resources in Kubernetes.
  • Users don’t have to know how to use kubectl. They create/delete resources with only simple operation of web UI
• supports settings that affect scheduling.
• accurately simulate and observe the behavior of Kubernetes scheduler.
  • spreading, affinity, preemption, etc.

SunPy allows visualization of spatially-aware data by means of Map objects. These objects have extensive 2D visualization capabilities for plotting various coordinate objects. This project primarily focuses on extending these various plotting and visualization capabilities of SunPy's Map objects into 3D by the use of PyVista, a 3D plotting interface for the Visualization Tool Kit (VTK). The project also focuses on writing extensive documentation and testing the functionality of the code along with the integration of plotting magnetic field lines from PfssPy as well.

There are several matrix implementations in Pharo. This project aims to compare all those implementations on different parameters like run-time, space efficiency, and features supported. Then, the project also aims to recommend an implementation that should be used for most use-cases or suggests writing a new implementation from scratch. The project will also explore popular matrix implementation in other languages like the Julia Linear Algebra and R matrix to find the missing functionalities in Pharo implementations.

Implementing a neural network with transfer learning for a new component of object detection in LearnBlock

Improvements to the corobo project enhancing its security, features and usability of coala’s devops bot.

With a surge of machine learning, especially the neural network model which needs to compute a huge amount of gradients, more and more languages' users begin to call for the ability to do high-performance and convenient automatic differentiation (hereafter AD) on functions, whereupon many AD tools are developed, among which is Enzyme. Enzyme is made as a plugin of LLVM and synthesizes differentiated functions directly on optimized LLVM IR code, which provides it with advantages in efficiency and universality. From another aspect, Rust is an emerging high-performance and safe language. Many of its users are trying to bring machine learning to it, thus an high-performance and user-friendly AD tool needed. Enzyme is a good option for this demand. However, without a deep integration into Rust, Enzyme's user experience with Rust is not so good, and more importantly, it may suffer from performance reduction due to wasted Rust meta-information. These problems hamper Enzyme from being widely used in Rust. This project will tackle the aforementioned problems through integrating Enzyme into Rust and then provide high-performance differentiation in Rust.

The goal of this project is to add Moving Least Squares surface reconstruction algorithms to the point set processing component. This family of algorithms reconstruct an implicit surface from a point set by fitting and projecting each point on a primitive (plane, sphere) fitting its neighborhood. The resulting surface is a smooth approximation of the input point cloud (smoothing degree is controlled by the primitive type and neighborhood size). Depending on the used primitive, several differential properties of the surface can be estimated.

Light & Shadow is an Alice in Wonderland themed gameplay mode which involves players working as two opposing teams to secure a flag from the enemy’s base and bring it back to their home base. The problem with the current implementation of Light & Shadow is the lack of viable resources/weapons in the inventory of the player that can be used to prevent the advance of the enemy team. This makes the game a race for the flag rather than a battle for the flag which definitely sounds less interesting. This project first focuses on stabilizing the current gameplay mode by fixing certain bugs and making a few improvements to the existing gameplay mechanisms and UI. It then tackles the problem mentioned above by introducing currencies and improving the inventory a player spawns with to allow for more defensive structures to be built and additional weapons/traps to be used along with various effects to help change the pace of the game. In addition to this, the entire module which is split in two has to be merged, interaction with the external modules improved, unnecessary code removed and documentation added.

Working toward 3.0.0 release

Text in a video often conveys information that is not easily expressed otherwise. This project will implement and compare the various existing state-of-the-art scene-text-transcription models and run inference of the best model on Java using legacy Java bindings of Tensorflow.

Pocket Code already implements face and text detection, text recognition, speech recognition and speech synthesization, but these features cannot be used by users with recent Huawei phones. The goal of this project is to support HMS Machine learning and Artificial Intelligence API, where other APIs are not available. So that they too can make use of these features.

A project to integrate NumPy, the leading package for scientific computations, into PySyft, a library for answering questions with data you cannot see. This will integrate core NumPy functionalities into PySyft.

Data-driven background estimation is crucial for many scientific searches, including searches for new phenomena in experimental datasets. Neural autoregressive flows (NAF) is a deep generative model that can be used for general transformations and is therefore attractive for this application. The MLBENDER project focuses on studying how to develop such transformations that can be learned and applied to a region of interest. In this project the main aim is implementing a Neural Autoregressive Flow (NAF) model to estimate the background distribution and apply it to a representative physics analysis searching for a resonance excess over a smooth background.

This project's primary aim is to tackle high priority issues and features for the mobile app, Allowing users to be more in control of the zulip experience through their mobile devices. Currently from a user experience perspective notification functionality has a lot of potential to be improved and so I will dedicate a good part of my summer for improving this feature. A higher level feature that is in demand involves encryption of sensitive user data, both at the device level as well as at the notifications and I am expecting to work on it as well. Further I will work to provide a profile UI in parity with the web app which a user will be able to update directly from their app. Another key feature that many apps use today include deep linking which allows the app to open using web links directly on the screen the user desires. Besides other things, This will be useful especially with invite links. Lastly, and this is a much broader topic, I would dedicate my free time to work on clearing abandoned issues and just plain simple bug fixes, that will aim to keep the repository more clean.

This Project aims to make Command Palette for Godot game engine that can execute some major editor actions available in editor menus. this project helps in increasing users productivity through keyboard and helps in memorizing shortcuts.

Checkstyle needs to have new Java grammar that is based on the newest version of ANTLR, version 4. This task is very difficult but it is critical for Checkstyle as ANTLR2 library is not supported (since 2006) and is far less efficient. ANTLR2 has a bunch of syntax analysis limitations that have already been resolved in ANTLR4. Checkstyle's current Java grammar numerous ambiguous rules, and requires many embedded actions and complicated constructs within the grammar itself; my proposed implementation will allow for a modular approach to solve this problem using a grammar that is very similar to Oracle's Java Language Specifications.

Elm's de-facto standard source code formatter, elm-format is based on Elm's 0.15 compiler parsing code. Since Elm 0.19 the compilers parsing code has been rewritten to eliminate the dependency on parsec and indents for parsing and to greatly improve performance. elm-format has however diverged from the compiler to the point where integrating this rewrite is nontrivial. The end goal of this project is to integrate the performance improvements from the 0.19 compiler into elm-format.

ZAP is a great tool to detect vulnerabilities of different kinds in web applications and generate alerts accordingly. However, it currently lacks a user friendly mechanism to revalidate or retest the identified weaknesses. This project aims to address this, by implementing a retest functionality allowing users to easily retest previously raised alerts, by simply selecting them and choosing the “Retest..” option in the right-click menu. This prevents users from setting up the entire scan again, thus saving time and effort.

A multisite will feature the admin panel of the talawa project. The accessibility of the admin to create, delete, completely block, read the flag request and send emails to the organization. The accessibility of the admin to create, delete, completely block a user, read the flag request and send emails to the user. The accessibility of the admin to create and post regarding any new update in the app. The accessibility of the admin to delete any inappropriate post and comment. The chat rooms will be monitored by the admin directly to stop inappropriate messages. The timely deletion of the User and Organization with a warning message after the User or Organization is inactive for a long period. Deleting the chat rooms created for the event after the event is over. The charity and donation plugin to create a portal that will manage all the transactions and other things as well and the rate will be manipulative. An algorithm to boost the ad after every count of the post will be implemented in the plugin.

TensorFlow Lite is a set of tools to help developers run TensorFlow models on mobile, embedded, and IoT devices. It enables on-device machine learning inference with low latency and small binary size. The TFLite Example Showcase allows for exploration of pre-trained TFLite models to learn how to use them in sample apps for a variety of ML applications. The new TFLite Task Library contains a set of powerful and easy-to-use task-specific libraries for app developers to create ML experiences. It provides optimized out-of-box model interfaces for popular tasks, such as image classification, question and answer, etc.

Currently, there are three NLP task examples using tediously written custom code instead of the TFLite Task Library - these tasks are for BERT Question and Answering, BERT Text classification and Smart Reply. The goal of this project will be to update these 3 existing tasks by building and testing the examples to use the TFLite Task Library instead of the previous custom code and documenting the processes with a code walkthrough - allowing developers to gain greater insight in how to use TFLite when building their iOS (Swift)/Android (Java) apps to complete these tasks.

This project is the continuation of the GSoC 2020 project OpenCV bindings for Julia. In that project, bindings for most of OpenCV’s core modules were successfully implemented. However, adoption still remains low because installing and using OpenCV from Julia is very complicated. This project aims to reduce the complexity and increase adoption by creating an easy-to-install version of the bindings and improving type conversion.

A Collision Detection system that is an alternate to Bounding Box and Precision Collision Systems. Used In Enigma to detect collisions in a game between objects and sprites.

This project idea proposes to implement two new credential bindings i.e. gitSshPrivateKey and gitUsernamePassword, that will contribute files and environment variables to sh, bat, and powershell steps so that they can use command line git to perform authenticated operations. Thus allowing Jenkins Pipeline users to run authenticated git commands in sh, bat, and powershell in a pipeline job.

Haiku has its own coding standards which describe how the code should be formatted. There is a tool for reformatting and checking if code follows these guidelines, but it has to be compiled on the developer machine and then run manually. The tool ‘ haiku-format ’ is work in progress which can be used to check the format according to guidelines which will be integrated with concourse to automate the process of checking coding style.

The goal of this project is to integrate tool with gerrit and develop the tool to give desired results, the web app Haiku uses for code reviews. It could then give quick feedback on the coding style as soon as a patch is submitted, making the review process smoother and easier.

cert-manager is a Kubernetes add-on used extensively to automate the management and issuance of certificates from various issuers.

This project aims to capture the problems users often run into when deploying cert-manager on managed Kubernetes solutions on different clouds with the help of improved e2e testing.

Gordf supports writing rdf triples to rdf file. Proposal is to create an interface that would take in a SPDX document and generate RDF triples out of it. Which will then be consumed by the gordf to generate a RDF/xml file.

Implement and improve several accessibility functions in Joomla! Keyboard navigation. Web accessibility means designing and developing your website so that people with disabilities can perceive, understand, navigate, and interact with, and contribute to the Web. Occasionally, the dispute over the definition of accessibility is revived. In fact, there are no contradictions between the two approaches. Design that recognizes the needs of all people also serves people with disabilities. Designing, for people with disabilities, brings benefits to all people - also people without disabilities. However, the term "accessibility" was defined to draw the attention of designers, not just web designers, to the specific needs of people with disabilities. W3C set up a Web Accessibility Initiative whose mission is to ensure that the web is accessible to people with disabilities including auditory, cognitive, neurological, physical, speech, and visual disabilities.

The project is about providing Ignition Gazebo with features of datasets generation to improve deep learning models training by implementing varies sensors such as labels camera & bounding box camera sensors, Also providing APIs to generate datasets rapidly from scenes.

The current print management tools only list the local queues and we have to use the web interface to work on queues shared with remote print servers individually. Since all these remote printers/scanners are IPP services, therefore we can instead display them all together including all the native hardware and printer applications along with it’s shared CUPS queues. This will provide the users who are not that well aware of web interfaces for network services a more comfortable GUI experience on a tool available in gnome-control-center. This will make navigating to the management interface of an IPP service a simple click through process for the user. This tool can also stretch it’s utility to become a general network service management tool for listing other non-printing DNS-SD services and provide easy navigation to their web interfaces.

Aerospaces sats

Enhance the functionalities in Python Honeypot Web Interface such as redesigning graphs, adding more graphs for better analysis, adding more export options, adding dark mode to the application, adding i18n for better support to users worldwide, integrating Grafana dashboard with the application, improving performance and many more.

The goal of this project is twofold: first, we wish to implement the graded ring of quasimodular forms and, second, we wish to implement the Bloch-Okounkov bracket that, given a shifted symmetric polynomial, produces a quasimodular forms.

After the introduction of SPDX Specifications v2.2 JSON, YAML, and a development version of XML had been added as supported file formats. However , the tools-golang packages currently does not have the support to parse the SPDX files nor has the support to save a SPDX document in JSON format .

The main objective of this project is to add support in the tools-golang package so that it can parse as well as save SPDX® v2.2 files in JSON format .

To add JSON support to the tools-golang package the project will make use of the official go JSON package . The SPDX specification has a JSON schema defined for the specification and has also provided a sample spdx document in JSON example format . The Project mainly comprises the JSON loader and the JSON saver . The former converts JSON to SPDX Document struct while the later generates JSON from SPDX Document struct .

The goal of the project is to develop a low-cost DIY robot kit, including the designs, tutorials and use-case scenarios. The DIY robot kit should be 3d-printed, assembled and operated using basic electronics and sensors.

Git has historically had many components implemented in the form of shell scripts. This was less than ideal for several reasons:

• Portability: Non-POSIX systems like Windows don’t play nice with shell script commands like grep, cd and printf, to name a few, and these commands have to be reimplemented for the system. There are also POSIX to Windows path conversion issues.
• No direct access to plumbing: Shell commands do not have direct access to the low level Git API, and a separate shell is spawned to just to carry out their operations.
• Performance: Shell scripts tend to create a lot of child processes which slows down the functioning of these commands, especially with large repositories.

The goal of this project is to complete the conversion of the remaining parts of git submodule to C, namely, the add and update commands. If possible, I intend to even get rid of the shell script called git-submodule.sh entirely, which currently calls submodule--helper to perform most of the business logic, and instead make submodule a proper builtin in pure C.

In this project, We’ll create an HTTP library that uses cronet (Chromium’s network stack) under the hood providing better performance, access to modern features (like - QUIC) and being great at handling network uncertainty which is an everyday scenario for mobile apps.

TensorFlow’s Model Garden and TensorFlow Hub contain the most comprehensive and easy to use model implementation for SOTA models. These implementations need to be lightweight and pretrained to SOTA numbers. They also need to be compatible with all Keras layers and operations. Recently, two of the arguably most fundamental models received an upgrade, namely ResNet-RS and EfficientNetV2. This project aims to implement these models and incorporate them in TensorFlow Hub and TensorFlow Model Garden. Moreover, I intend to make tutorials and solve issues related to the same and beyond.

In this project we are trying to provide a High-level API for the Deep Learning engineers and researchers to help them train their models faster, and provide them many other various features:

• Users can train/evaluate/test models with this API.
• Users can train multiple models/optimizers on multiple datasets.
• We provide a lot of features like (integration of experiment tracking systems, auto-batching, auto-checkpointing, automatic-mixed-precision, train GANs, Semi-supervised learning, DDP, etc....)
• We provide examples for using each and every feature in this API.
• We provide good documentation.

Property Wrappers are responsible for wrapping common getting and setting boilerplate and also for storing any auxiliary helpers. Often, these helpers are the same across different instances of the wrapper. Thus, having to store it in each individual wrapper instance is a waste that should be avoided. We can solve this by introducing a static storage that is shared across instances, within the scope of where they are declared. Thus, providing a tool for property wrapper authors to optimize their wrapper abstractions.

@propertyWrapper(shared: Storage)
struct Clamped {
private var value: Value

struct Storage {
    let range: ClosedRange<Value>
    init(_ range: ClosedRange<Value>) { // ... } 
}

// wrappedValue would be accessed through a subscript
subscript(shared storage: Storage) -> Value {
    get { value }
    set { value = storage.range.clamping(newValue) }
}
}

The goal of this project is to provide typed API for LuaRocks modules, specified using Teal, a typed dialect of Lua, which allows for typed definition files to be written for untyped Lua modules. Our goal here is not to port all of LuaRocks to Teal, but to provide typed interfaces for Teal or Lua applications, so that users of these interfaces can have a stable contract of the API's inputs and outputs.

CGAL currently supports the decimation of triangular meshes using two distinct strategies: Lindstrom-Turk and Garland-Heckbert. These strategies assign a cost to each edge collapse so that edges can be iteratively collapsed in order of least cost until a condition is met.

Our focus is on the latter of the two strategies, which uses quadrics at each vertex to calculate a cost. The paper Fast and Robust QEF Minimization using Probabilistic Quadrics explores the use of probabilistic - as opposed to classic - quadrics and shows that in many use cases, including but not limited to mesh decimation, probabilistic quadrics give better results, are more robust and about as efficient as classical quadrics.

The aim of this project is to introduce support for probabilistic quadrics in the context of mesh decimation in CGAL, which would improve the library's capability to quickly generate highly desirable mesh simplifications.

The main objective of the project is to build a consistent API leveraging MNE-Python to perform connectivity analysis of neural time-series data, such as MEG, EEG and iEEG. The result would be “mne-connectivity” a Python3.6+ software package that allows scientists to explore connectivity based analysis using published algorithms with few barriers because it leverages the widely used open-source platform of MNE-Python.

Create a new engine to support Faery Tale Adventure II: Halls of the Dead by The Dreamers Guild.

The Wikipedia Preview acts as a medium that provides Wikipedia content in the form of contextual information to be available on 3rd party sites. It consists of showing information from Wikipedia projects that involves images, definitions or reading more content related to an article directly from the provider’s website. It helps users to gain contextual details from Wikipedia without actually visiting it. Whenever a reader hovers over a link to an article, a short summary of the subject and an image (if available) will be displayed.

The goal of the project is to enhance the working of Wikipedia-Preview by testing the preview against test cases. This involves writing a quality level of tests that checks the preview on different parameters. This will help in identifying the fallback conditions and help in delivering better Preview to the end users.

The project involves writing cypress tests for Wikipedia-Preview. Cypress provides a better interface for writing, running and debugging standard test cases for the projects developed in javascripts.

A Swift BitArray that stores 8 times more data in the same amount of memory! Primarily, the BitArray is an array of Booleans (like Array<Bool>) Each Boolean stored in the Array<Bool> takes up one byte of memory, as a variable cannot be any smaller, but a Boolean only needs one bit to differentiate between true and false. Hence, for every element added to an Array<Bool>, 7 bits of memory are technically wasted.

A BitArray optimizes this by making use of each bit by storing the values into a UInt8, with each bit of the binary number of the UInt8 representing a Boolean value (1 for true and 0 for false). It would make use of clever bit operations for storing, retrieving, changing, and removing values.

The API can be implemented as an array of 1-bit "Booleans" or an array of small integers which hold the indices of the true values. Either way, the memory used is far less, and both API implementations allow for different benefits. The ideal would be to implement both, with one being the primary API.

Extracting metadata from AV1 videos is very useful for codec research. They can be used to create a video analyzer, analyze coding performance of a video, encoder development and many other purposes. While there is a way to extract metadata by using the reference decoder, libaom, the process is slow and extraction of sophisticated metadata is lacking. The goal is to create a lightweight rapid metadata extraction tool which extracts all the relevant metadata from the decoder end for research and development of AV1 tools. The aim for this project is to use dav1d, a fast decoder, to extract metadata similar to how libaom extracts metadata and build up further by extracting more information such as residual data, performance data, add more compression options for JSON and grant the ability to store in binary.

This project aims to implement Automated Visual Regression Testing alongside the current testing infrastructure to ensure robust testing coverage.

My proposal is about improving the robustness of MifosX and Apache Fineract by fixing issues/feature requests from the backlog. There're currently 5 issues attached to this idea. Some of them contain UI improvements as well as the server side implementations. Also I'm willing to take up the "Collateral Module" feature request which will be linked with this idea. I've written my ideas on each and every issue linked with this in a detailed manner.

My goal for Google Summer of Code is to make OONI better at measuring TLS and QUIC blocking. OONI develops the open source software OONI Probe which provides tools for measuring internet censorship. QUIC is an emerging transport protocol that was initially designed by Google to solve problems with the existing TCP/TLS architecture. With increasing traffic volumes, it is significant to observe and measure QUIC blocking.
I want to identify and resolve existing inconsistencies with the QUIC code that I have contributed earlier this year.
Eventually, the QUIC code should get to a point where it can be used in production by the Desktop client. Therefore, the first deliverable of my GSoC project will be to integrate QUIC support into the OONI Web Connectivity experiment.
The second part of my project will be to implement the capability to parrot the TLS fingerprints of popular web browsers. TLS fingerprinting is a censorship method which identifies browsers based on the structure of the TLS ClientHello message. The ability of parroting TLS fingerprints will enable OONI Probe to measure and circumvent TLS fingerprinting.

100 Paper Cuts aims for improving user interface, implementing enhancement requests and solving most-annoying issues on the UX side of LibreOffice.

Sample Platform is CCExtractor’s platform to manage tests, upload samples, run regression tests and much more. The main purpose of the platform is to test each and every pull request of the CCExtractor repository with the samples uploaded (which currently has 180GB of samples) and report status. This will ensure the pull request being merged is safe and secure.

Currently, the sample-platform runs a test using KVM instances, so it is capable of running only one test at an instant which is a major drawback. With a lot of cloud offerings available, the process of running tests can be parallelized thus making the system more efficient and powerful.

With the migration of sample platform from KVM to Google Cloud platform, long run time issue can also be resolved which happens when there are a lot of commits or pull requests opened.

The project aims to design and develop a Peer-to-Peer Messaging app that does not rely on a central server to send messages across the peers. The app is intended to provide privacy, high communication-efficiency, censorship resistance and extra resilience to the users.The app should be reliable and usable dependent/independent of network connectivity.

Adding support for the multiprocessor ACPI APIC HAL

Scan8 is a kubernetes based rapid URL/file scan system that allows users to submit a list of URLs/file and take out the scan results.Scan8 uses ClamAV open-source antivirus project as the scan engine and Google gvisor as the container sandboxing for k8. The overall system is able to create a large number of lightweight ClamAV containers (Pods) and distribute the scan list on demand and take out the scan result within a short amount of time.

It is common for compilers, and LLVM in particular, to transform calls to memcpy or memmove to a number of integer loads and stores of the corresponding bit width. After, load and store instructions can be optimised further. However, semantics of memcpy and memmove specify that the memory is copied as-is in bytes, and LLVM does not have a type to represent the handle to the raw memory (like unsigned char or std::byte in C/C++). This leads to incorrect transformations and miscompilations.

This project aims at introducing a new byte type to LLVM IR to fix miscompilation issues and to make the semantics of type punning in LLVM consistent.

To improve triage and tracking of reports: (A tool to append new scans to previous scan reports A combining tool to merge different reports )

To improve structure of cvedb.py (Not reinitialize the database in case of timeout or some other problem A way to download only the modified NVD files rather than initialising the whole database every time. This feature can be included for users who want to run scans very frequently .)

The most frequently used Ruby Core APIs Kernel::require and Kernel::require_relative are doing the same work: it’s to resolve the file path, read the file, compile ruby source to bytecode or load a shared object, evaluate and add an entry to $LOADED_FEATURES . But if using Ruby stdlib benchmark to profile their performance, we can figure out a fact: require a relative path is almost 10 times slower than require an absolute path and about 4 times slower than require_relative the same path. This proposal aims to figure out the reason and optimize it.

This project aims to add portable implementations for SIMD ISA extension AVX-512 functions which are not yet supported by SIMDe. This will make development with highly optimized code more universal and allow developers to write and test vectorized code for many applications even without access to specific hardware.

PcapMonkey provides an easy way to analyze .pcap using Suricata, Zeek, and Elastic SIEM. The goal of this proposal is to improve and enhance PcapMonkey to help analysts work faster. A broad list of work to be done in the project during the summer is:

• Improve Suricara, Zeek, and .evtx integrations.
• Follow standard Elastic Common Schema.
• Implement a test architecture for PcapMonkey.
• Addition of multiple functionalities like live traffic analysis and Zeek Package Manager integration to take PcapMonkey further.

irde.st is a software suite that allows users to create an internet-independent, decentralized & ad-hoc wireless mesh network. It removes all the dependencies of a user from a specific service and enables users to create a local network mesh of their own. It does not expose data or information of the user, even the IPs of the peers present in the mesh are not known they communicate via routers and the entire communication is end-to-end encrypted between the users, thereby increasing privacy in user data. As of now, Irdest supports various functionalities to users like sharing files over the network created, call between users. messaging.

This summer I plan to package and implement some of these core functionalities in an android application. The project aims at first building the FFI layer for interaction between the rust lib code and android, and then implementing the features required. The final product/deliverable of this project will be an android application that'll support the features which are provided by Irdest in the upstream.

Metatheory.jl is a general purpose metaprogramming and algebraic computation library for the Julia programming language, supporting the novel technique of e-graph term rewriting through equality saturation, first introduced in egg. Our contribution allows performing general purpose symbolic mathematics, manipulation, optimization, synthesis or analysis of syntactically valid Julia expressions and user defined types, with a clean and concise programming interface, both during compilation or execution of programs. We have been currently experimenting with optimizing mathematical code and equational theorem proving strategies. Some of the proposed tasks for this project include:

• Experimenting with Symbolics.jl integration and optimization for symbolic mathematics.
• Experiments in optimizing lowered Julia IRs (possibly by statically overlaying methods with Mixtape.jl), allowing users to define concise rewrite systems that directly optimize Julia code.
• Experimenting in encoding category theory axioms to efficiently model string diagrammatic equational reasoning, and to produce human readable equational proofs. Possibly, integrate this rewrite system with Catlab.jl

Currently the gora-sql module is outdated and only supports mysql database scheme. This module can be rewritten in JOOQ in such a way that it can support any Relationshional database store [2]. JOOQ is a widely used Java framework which helps to build applications where persistence requires and is highly regarded by industry specialists over Hibernate & JDBC [2]. Hibernate itself is very distant from normal sql queries and JDBC has security concerns and also too much hassle when it comes to transaction handling. JOOQ will be a very good addition to the Apache Gora project as it creates a path for Relational databases to work with apache gora seamlessly.

LoopSim framework aims to facilitate workflows with loops i.e workflows without specific start and end services. LoopSim requires an interface to create these types of workflows using some kind of graph.
It currently relies on a Closed Source software yEd - Graph Editor for workflow creation. The objective of this project is to remove this dependency on a closed source software and build an open-source solution tailored for LoopSim requirements.

We also need to integrate this project with the existing parser so as to automate the flow from running the script and building the workflow to parsing it. The proposed solution will make it easier to web host the LoopSim project.

Following the spirit of Everything Nodes, I think it would be better if we have a Testing Framework in place for the Geometry Nodes.

• Quickly detect bugs.
• Geometry Nodes is still new and under development, so a lot of changes happen.
• Would help in detecting if anything breaks.

ChemTools is an open-source Python library for interpreting quantum chemistry calculations. It is currently the only library capable of interpreting those calculations using Conceptual Density Functional Theory – a framework that has matured over the last four decades, but still lacks exposure to practicing chemists.

In this project, I will contribute to ChemTools library by incorporating two popular quantum chemistry libraries – PSI4 and PySCF. This will result in a much better cross functionality and give practicing chemists a one-stop library for both performing and interpreting quantum chemistry calculations.

I am interested in giving Juice Shop’s score board some TLC (tender love and care) and making it easier for beginners to understand their progress. I wish to do this using simple UI and managing assets and information to optimize the render speed. The goal is to make progress easier to track for beginners whilst also allowing pros full visibility. My proposed contributions will include: separating challenges from progress so as not to overwhelm beginners; featuring challenges based on user’s comfort level (ie., "Try out this ⭐⭐⭐ challenge"); giving each challenge category its own progress bar and checkpoints (this can be toggled on and off and is secondary to the complete progress); some of the solved challenges could be accompanied with a "How We Solved It" instructional guide outlining solutions from Bjoern Kimminich's "Pwning OWASP Juice Shop" guide; making progress stars lead into more information (ie. click on the first ⭐ and reveal all the solved challenges from the one-star category); for fun: Request juice box icon from FontAwesome and potentially make difficulty levels juice themed (🧃 instead of ⭐) to maintain thematic consistency

This project aims to enable JavaScript visualizations in TOPPView using Qt WebEngine and its different modules.

This proposal is all about adapting Schema Editor to work with ModelState in spite of the model classes.

1. The first milestone is to create a central registry that could store all the relations between models.

2. The second milestone would be, to create method mapping in ProjectState for all Opertion subclasses' state_forwards and state_backwards. For Example CreateModel.state_forwards calls into ProjectState.add_model_ where all the logic is encapsulated. Similarly, there would be new methods in ProjectState like alter_field, rename_model and so on that would be called by the state_forwards of respective Operation subclasses.

3. The third milestone would be, to update SchemaEditor methods and properties along with all database_forwards and database_backwards methods in order to adapt ModelStates.

Liquid Galaxy as a meaningful presentation tool has a lot of information that can be displayed for diverse purposes like an educational tool, or for a monitoring system. With that in mind, the idea of ​​the project is the real time visualization of satellite images that would be attached as layers of google earth, besides being able to have diverse information of the earth being graphically generated as storms, fires, masses of heat and water vapor, a synchronous earth visualization will allow for more complex interactions. From there, the entire application would be controlled through a script responsible for managing calls made to the satellite's external APIs (e.g. NASA API and Copernicus) that responses with the metadata necessary for the kml creation and a tablet application that would give the user control of which layers or information would like to be displayed and responsible for handling the API calls, manipulate KMLs and sending them to Liquid Galaxy through Bash scripts. The application’s front end will be developed with Flutter and the image selected by the user will be generated based on selected options

I propose to add OnCanvas Alignment Guides to Inkscape. When enabled, while moving objects around the selection will snap to temporary Horizontal or Vertical guide lines that will appear if the selected object can be aligned relative to another object on the canvas.

Alignment guides are Horizontal or Vertical lines that only appear when you're editing objects on the canvas. They provide more contextual information about and objects X/Y position relative to other nearby objects. As you get closer to align the selection with the edge of another nearby object, the selection will automatically snap to that position and an Alignment Guide that coincides with the (now aligned) edges will appear to indicate that a snap has indeed occurred. This guide can be in vertical or horizontal direction depending on the optimum snap found.

Addition of alignment guides will imporve UX and make the task of aligning objects relative to each other easier.

The aim is to implement a decoupled, publish-subscribe-based continuous integration (CI) and delivery (CD) solution that allows developers to notify deployments of available updates, which can then autonomously decide what to do with them. The broker would manage subscriptions for update notifications for each deployment, offers an endpoint that listens for updates, builds and publishes container images and notifies services.

ModelBricks is a tool for bioinformatics researchers that allows users to browse, view, and download detailed models of biological processes. I propose that various needed visualizations, and model retrieval functions are added using the existing code framework and the VCell API. Furthermore, I propose that the VCell API be expanded to include useful functionality such as more versatile searching and permissions changes.

Modification of current code with ES7 and JSX( JavaScript eXtension ). Improving UI by making it more user friendly.

This project is to build a dashboard that will deliver features to enable an admin handle activities. It will offer filterable Pivot Table of Activity, and also provide meachinism for the admin to select an Activity Type and date period and delete the Activities including any related data in the log tables (if used).

In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation.

ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. ROOT has a clang-based C++ interpreter Cling and integrates with Clad to enable flexible automatic differentiation facility.

TFormula is a ROOT class which bridges compiled and interpreted code.

The project aims to add second order derivative support in TFormula using clad::hessian. The PR that added support for gradients in ROOT is taken as a reference and can be accessed here.

Optionally, if time permits, this project will also convert the gradient function into CUDA device kernels.

This project aims to add enhancements to Scrapy's Feed Exporter components. These enhancements consists of item filters, feed post-processing and batch delivery triggers. Currently there are no convenient ways to filter items before they can be exported. Item filter feature will provide such ways and interface. A Feed post-processing enhancement will enable plugins such as compression, minifying, beautifier, etc. which can then be added to the Feed exporting workflow. Batch creation was a recently introduced feature but was limited to only item count constraints. Batch Deliver triggers will be able to make the constraints flexible and give more control to user to create batches.

The Idea for this project is to bring in the global timeline to ease certain types of tasks and increase productivity. This will essentially bring in a non-zoomable Timeline which will serve to ease the task of trimming, cutting, rearranging clips on the timeline in sync with the other timeline.

Fabio Gandolfi gsoc username: zwerg4 email: fab.gan@hotmail.de github: zwerg4

My name is Fabio Gandolfi, I am a 24 years old computer science student of Italy but currently living and studying in Austria.

I am very interested in programming in a lot of different programming languages. Currently I am studying Computer Science in Graz (Austria). I would propose to the iOS team where I already contributed some new features and therefore already have an overview how the app is built.

INTEREST: Pocket Code for iOS: Support for Catrobat Language version 0.994 - 0.99992. This task seems interesting to me and I would like to implement it during the summer to bring also some new compatibilities to the iOS app.

Since I already contributed to your amazing project and really liked it a lot also because I learned a lot of new things and because I think it has a lot of potential I am really looking forward to work with you also in the Google Summer of code.

Fundamental questions about Thermonuclear Supernovae (Type-Ia or SNeIa), the beacons visible across the universe, remain unanswered. Using the currently-available extensive library of detailed supernova simulation data, I aim to identify machine learning and computational techniques suitable for this project, produce a cluster-predict model that identifies cluster classes based on observable parameters, characterize the degree of confidence of the model, and ultimately establish classification metrics for Type-Ia supernovae to prepare for future nuclear astrophysics investigations, advancing our understanding of these beacons of the cosmos.

This project, based on this idea by the Pitivi team, aims to implement an easy to use feature which lets users quickly synchronise their edits - be it clips, photos, or any kind of transitions in between - with the music they put in their videos.

After the user chooses an audio track to sync the clips to, a 3rd party library like librosa will be used to detect the tempo and timing of beats there. If it succeeds, Pitivi will provide the user with points on the timeline that they can 'snap' their clips to, each one representing a beat in the chosen track. For quick and easy usage, users will also be able to just choose some pictures from their library and have Pitivi automatically sync them to the music of their choice. Advanced users, on the other side, will have the ability to change settings like beat snap divisor or manually specify the timing and tempo of their song, to ensure they get the desired results.

Update the user interface of vlc-ios to match or surpass the Android app.

Clang Static Analyzer has an in-built constraint solver which is trivial but pretty fast. The aim of this project is to introduce support for range-based logic for binary operations.

FALCON is the current state-of-the-art Multiparty Computation (MPC) Framework for Private-Deep Learning(PDL).MPC allows mutually distrusting parties to jointly compute a function without revealing their private inputs beyond what is revealed by the output of the computation. PDL allows multiple parties to collaboratively train a Machine Learning model without revealing their private inputs. It also encompasses secure prediction.MPC is one of the privacy advocates for PDL.

The project aims to implement FALCON in the SyMPC library. It would greatly improve the performance of the SyMPC library for training and inference.

Talawa App already has the English language at the moment. As the app is being targeted to a broad audience so we need to support more language for great user experience and engagement. While the current language will be reused, we will be changing its hardcoded nature in the widgets (like app bar, buttons, form fields etc) to a more dynamic one. Users will be allowed to easily switch the language of their choice during Signup or Login. Users will also have the capability to change the language inside the app. Talawa app aims to build a strong and meaningful relationship among the members of the organizations with the help of features like group chats, news feed and events. Therefore making sure of effective communication between people of different language is also necessary. Modification in the backend will be done accordingly to help different language users to communicate effectively in groups. This project idea serves to solve the barrier of communication which can hinder the growth of the community through the Talawa app.

In this project, we will attempt to embed FreeCAD into Pharo Smalltalk IDE, such that Smalltalk code can drive FreeCAD directly. With a pure object-oriented programming environment and excellent debugger that Pharo provides to the user, we aim to create a productive CAD scripting tool within the Pharo environment. This tool will have the flexibility of scripting that Smalltalk provides, and the speed of C++ to produce CAD visualisations immediately; which is very conducive in rapid-prototyping and multi-disciplinary projects.

Kolibri has a Tasks API that runs time consuming tasks asynchronously outside of HTTP request / response cycle hence unblocking the HTTP connection for other requests.

The current Tasks API backend has a very poor consumer experience. Adding new tasks require plugin developers to inherit from kolibri.core.tasks.api.BaseTaskAPIViewset class which adds in multiple extra endpoints for handling of this new task.

The current architecture makes it a tiring experience for plugin developers to submit and monitor their custom tasks. It also disturbs the core Tasks API code and has heavily polluted kolibri.core.tasks.api module.

This project fully revolutionizes the Tasks API backend.

This project aims to make it super straightforward for plugin developers to submit, monitor and manage custom asynchronous tasks with a simplified backend architecture.

The result is:

• Plugin developers can submit any custom task by POSTing to just one endpoint.
• Plugin developers can manage and monitor their tasks via specific and consistent endpoints.

And most importantly, this makes the Tasks API super duper easy to work with.

The functioning of complex systems (i.e. the brain, and many others) depends on the interaction between different units; crucially, the resulting dynamics is different from the sum of the dynamics of the parts. In order to deepen our understanding of these systems, we need to make sense of these interdependencies. Several tools and frameworks have been developed to look at different statistical dependencies among multivariate datasets. Among these, information theory offers a powerful and versatile framework; notably, it allows detecting high-order interactions that determine the joint informational role of a group of variables.

The goal of this project is to collect and refine existing metrics of high-order interactions currently implemented in Matlab or Java, and integrate them in a unified python-based toolbox. The main deliverable of the project is a toolbox, whose inputs are the measurements of different variables plus some parameters, and whose outputs are the measures of higher-order interdependencies. Ideally, the toolbox will interface with visualisation & processing platforms of neuroimaging data, such as MNE, fMRIPrep and can become a docker container too.

In this proposed project we build JaxModel, which provides a high-level API for training and deploying Machine Learning Models using JAX framework. The main goal for JaxModel will be to provide an API for building, training, and testing deep learning models which are compatible with the existing DeepChem code base which already provides features like Molnet, Featurisers, Splitters, Transformers, and other deep learning infrastructures. During the period of GSOC, I will also be adding a notebook tutorial specifying the usage of JaxModel. If time permits, In the same tutorial I will also use an advanced JAX-based model preferably (Graph-based model or Physics Informed Neural Networks). This will be the beginning of implementing JAX-based models into the main DeepChem repo.

Adds a new List component to React Admin which implements infinite scroll to the Navidrome Data Views

The idea behind the project is to create a hydra-powered REST API that aims to serve the loan portfolio data to various consumers for regulating, valuation, and various other purposes. This project will be a prototype of "APIs for Fintech" with Hydra Ecosystem.

zfit is a highly scalable and customizable model manipulation and fitting library. Using Tensorflow as its backend, it has been optimised for simple and direct manipulation of probability density functions with usage target High energy physics analysis ecosystem. The main focus is on scalability, parallelisation and a user friendly experience framework (no cython, no C++ needed to extend). Zfit currently misses library functions which are especially useful in physics. My aim is to implement a new library function named Faddeeva function or Kramp function that can simplify the process of calculation of scaled complex complementary error function. This function arises in various physical problems, typically relating to electromagnetic responses in complicated media.The purpose of this new library function is to cater to the needs of scientists and researchers with minimal knowledge of low-level implementation of the function with high performance and accuracy.

3Dmol has most of the necessary features that make it a good visualization plugin for application and web. But this tool becomes difficult for the audience that is not familiar with web technology. Making its features inaccessible and making it harder to use as compared to similar applications like VMD, Visit, ChimeraX, PyMol etc. Hence there is a requirement of an UI that can make 3Dmol more accessible to the audience. To achieve this a layout for UI and additional controls for camera are proposed. That can expose all the features of 3Dmol. This will make 3Dmol easier to use and increase its application in general discussion, teaching and presentations.

Webiu is a “generalized website builder” which magnificently eases the essential process of getting a website up and running easily. The project provides almost all of the different sections required by a normal website as different reusable components. This project proposal aims at adding and implementing new features and functionalities into the current project to make it more reusable and accessible and further ease the process of building a website. Creating a logo, improving current components functionally, developing new components, creating an NPM package for Webiu, documenting the components using Storybook are some of the works (but not limited to) proposed. The proposal when implemented will functionally improve the current project, increase the range of the project and make the components accessible to other developers to incorporate them for developing websites.

I plan to write SIMD assembly for the new tx (transform) subsystem in FFmpeg, targeted at AArch64 for double precision inputs.

Metabolic modeling has been interwoven with constraing-based methods. The value of randomized sampling in the framework of metabolic modeling has been proved itself over the years (see Schellenberger and Pallson (2009) and Herrmann et al (2019)). Aim of this project is to integrate the produced data and knowledge of these twenty (and more) years and make use of the randomized flux sampling method to evaluate the metabolic interactions retrieved. To this end, thousands of publicly available reference microbial genomes will be selected, and their automatic metabolic network reconstructions will be implemented. Based on these models, cross-feeding interactions algorithms will be performed for groups of species to extract key metabolic processes. New functions, implementing the recently developed Multiphase Monte Carlo Sampling (MMCS) algorithm in the framework of the dingo library, will make use of the randomized flux sampling concept to evaluate the processes retrieved.

The International Image Interoperability Framework (IIIF) describes a standard to interact with images that are being adopted by an increasing number of museums, archives and other institutions that store large collections of digital images. The aim of this project is to make vitrivr compatible with the APIs specified by IIIF so that it can be used to interact with any IIIF capable data sources easily. The primary goal of this project is to allow Cineast to download files from a IIIF compliant server and extract features through these files using the extraction service.

Current limitations with the variant detection using wbtools (and entity extraction in Wormbases’s AFP pipeline) is that it relies on regular expression and string matching with database. This approach can not be scaled to the entities or variants which do not have a clear pattern or are novel - especially relevant when there’s a lack of common consensus in SNP nomenclature.

This proposal, in short, aims to increase entity detection capabilities of the AFP pipeline (and variant or strain detection capabilities of wbtools) by integrating more data models in the current pipeline, and for cases which aren’t possible to be generalized using a data model, use the present curated databases to train Named Entity Recognition (NER) using BERT to extract data from papers. Then, validate the discovered SNP by using NCBI’s Basic Local Alignment Search Tool.

Learning equality’s specific goals for this year has been to continuing to develop and improve upon key features of Kolibri App, one of the primary goals being is to build out a diverse content library and a wide array of content that caters to multiple different subject areas.

Kolibri App uses the Khan Academy Perseus framework to display assessments to learners, collect interaction data, and provide feedback, but the types of questions supported by this framework is only suitable for maths being insufficient for many other subject areas. The tool to support the creation of assessments are currently only limited to four types of questions.

A new feature, the Kolbri-Assessment Delivery System is under development for the purpose of supporting an interoperability standard called QTI (Question and Test Interoperability) that will allow us to create assessments, import and export question banks to a valid QTI xml format and expand the types of questions types that can be utilized within Kolibri for assessments (i.e. essays, drawing on a photo, etc.). This feature will try overcome the short comings of the Perseus framework, no longer being supported by Khan Academy development team.

Cert-manager can be installed using Helm or with regular Kubernetes manifests, but when using regular manifests it is difficult to customize the deployment. This CLI will make it easier for non-Helm users to customize the configuration of cert-manager, it will provide a way to see all the configuration options for a cert-manager deployment from the command line (i.e. by running kubectl cert-manager install --help). It will provide an option to wait for and verify the deployment, perhaps by integrating the code of cert-manager-verifier. And it may become the foundation of a future kubectl cert-manager upgrade command, which will help users safely upgrade and downgrade between cert-manager versions.

Robustly identify standard visual fiducials for AprilTags and their orientation. Create a general method in OpenCV of turning a sufficiently textured planar tag into a fiducial that allows for position and ID.

The goal of the project is to use ML techniques to identify relationships between planetary mapped datasets, with the goal of providing deeper understanding of planetary surfaces and to have predictive power for planetary surfaces with incomplete datasets. There are three main proposals for the stated problem:

1. Explore various ML models, adjust the parameters and compare their performance. During the preliminary work, I already explored several basic ML models; however, we should try more advanced ones and perform a deeper comparison depending on the parameters and metrics.
2. Predict chemicals from chemicals. Based on preliminary work, we see that although in Mercury the correlation between albedo and chemicals is low, the correlationships between some chemicals are pretty high. Thus, in order to fill the "gaps" in the chemical maps, we could try to predict one chemical based on some others.
3. Perform convolutional prediction. Rather than using only one corresponding pixel for the prediction, we could include the surrounding pixels since they might offer additional information.

My main goal during this project will be to improve the tooling and testing infrastructure of Zulip. Along with this, I will also work on adding useful integrations to Zulip.

Introduction

• The BeagleWire is an FPGA development platform that has been designed for use with BeagleBone boards. BeagleWire is a cape on which there is an FPGA device (Lattice iCE40HX). The software support for BeagleWire is still in the development phase.
• In this project, I'm developing and testing the existing software support of Beaglewire. The known primary issue in Beaglewire is the interface between 32MB SDRAM and ICE40HX4K. For this Solution, I'm going to try options like LiteDRAM(a small footprint and configurable DRAM core).

Testing and Improvement of Subsystem Like I2C, SPI, PWM, UART

• In this project I'm going to test all the subsystems like I2C, SPI, PWM, UART in Hardware and the primary goal will be to debug the issues related to them and fix them accordingly. Along with the driver code ready to use solutions will be added in software support.

Others

• There are current Issues open on BeagleWire Repository, These will be solved during this project.
• More PMODs will be interfaced with the BeagleWire.
• Increase the Documentation and also add getting started guide for BeagleWire.

This project aims to add the NATS messaging system to the current list of CEPH’s bucket notifications endpoints. Bucket notifications provide a mechanism for sending information when certain events are happening on the bucket to external systems. Adding NATS as a cloud native messaging solution will be useful as CEPH can run inside Kubernetes.

Briefly, the problem is detecting the course markers to help an autonomous vehicle find an optimal trajectory to complete the circuit. The idea is to develop an algorithm that will help a controller, which will first be demonstrated on an autonomous car that will navigate a closed course in minimal time. An embedded device(Raspberry-Pi) will be used to take live video input and run the algorithms on it.

This project aims to write frontend tests to fully cover each service, directive, and components in order to ensure that the quality of code throughout the codebase is maintained saving time for developers and providing a better, bug-free experience to the user.

A feature that will allow pasting special text into Joplin and have it converted to Markdown

This project will create a modular framework for world generation in Destination: Sol. This will allow more flexibility in the way the world can be generated. Instead of the current system which has very few options for world generation, this project will lay the foundation for a system which can support many options.

The current version of OWASP Nettacker needs some improvement in WebUI. I will make some changes to each page of the WebUI/API to make it look cleaner and cooler. My work will include changes in Basic and Advance Scan improvements in the New Scan Page. I will be changing the layout for the results and crawler page. Also, the changes will be done to the Page where individual results are shown in form of a Graph.

Developing Deluge Client using flutter and dart along with modern material interface.

This project aims at enlarging the reach and approach-ability of youngsters to circuit design through a block based approach of the TL-Verilog Language. This will further enhance the toolset of the MakerChip IDE and bring more people towards simple, concise, circuit design.

People with special-needs face a variety of different challenges and barriers that isolate them from their surroundings. Nowadays, several assistive technologies have been developed to reduce many of these barriers and simplify the communication between special-needs persons and the surrounding environment. However, few frameworks are presented to support them in the Arabic region either due to the lack of resources or the complexity of the Arabic language. The main goal of this work is to present a mobile-based framework that will help Arabic deaf people to communicate ‘on the go’ easily with virtually any one without the need of any specific devices or support from other people.

NuttX is a real time operating system which provides wide support for smaller and cheaper microcontrollers and development boards. PysimCoder is an open source Rapid Control Application Design tool which is able to transfer block diagrams into C code. Main goal of the project is to integrate and test pysimCoder support for various kinds of drivers supported by NuttX. The main target platform is iMXRT1060 MCU, but some other platforms like STM32 or RISC-V ESP32-C3 can also be considered for testing and demonstration.